function getFlexApp(appName)
{
  if (navigator.appName.indexOf ("Microsoft") !=-1)
  {
    return window[appName];
  }
  else
  {
    return document[appName];
  }
}

function getMapApp()
{
  if (navigator.appName.indexOf ("Microsoft") !=-1)
  {
    return window["index"];
  }
  else
  {
    return document["index"];
  }
}

/**
* 地图居中
* 
* @param mapX 地图中点 X 坐标
* @param mapY 地图中点 Y 坐标
*/
function centerAt(mapX, mapY)
{
	getFlexApp('index').centerAt(mapX, mapY);
}

/**
* 地图向上平移
*/
function panUp()
{
	getFlexApp('index').panUp();
}

/**
* 地图向下平移
*/
function panDown()
{
	getFlexApp('index').panDown();
}

/**
* 地图向左平移
*/
function panLeft()
{
	getFlexApp('index').panLeft();
}

/**
* 地图向右平移
*/
function panRight()
{
	getFlexApp('index').panRight();
}

/**
* 刷新图层
* 
* @param layerId 图层id。对于图形层，为图层的 name 属性，默认值：高亮层=“高亮层”，动画层=“动画层”；对于要素层，为服务中对应图层的名称，而非图层的 name 属性。
*/
function refreshLayerByID(layerId)
{
	getFlexApp('index').refreshLayerByName(layerId)
}

/**
* 刷新图层
* 
* @param layerName 图层名称，图层的 name 属性，config.xml中的 layer 标签的 label 值。注意，ags 中并不限制图层重名，因此，本方法刷新所有同名图层。
*/
function refreshLayerByName(layerName)
{
	getFlexApp('index').refreshLayerByName(layerName)
}

/**
* 删除所有图层
*/
function removeAllLayers()
{
	getFlexApp('index').removeAllLayers();
}

/**
* 清空所有图形
*/
function clearAllGraphics()
{
	getFlexApp('index').clearAllGraphics();
}

/**
* 清空图形层
* 
* @param layerId 图层ID，高亮层=“高亮层”，动画层=“动画层”
*/
function clearGraphicsLayer(layerId)
{
	getFlexApp('index').clearGraphicsLayer(layerId);
}  
/**
 * 
 * 删除图层上的某个设施
 * @param layerId
 * @param featureId
 */
function removeFeatureInLayer(layerId,featureId)
{
	getFlexApp('index').removeFeatureInLayer(layerId,featureId);
} 
/**
* 交互打印地图
* 
* @param title 正标题
* @param subtitle 副标题
*/
function printMap(title, subtitle)
{
	getFlexApp('index').printMap(title, subtitle);
}

/**
* 闪烁点
* 
* @param pointsString 点字符串
* @param delay 闪烁间隔（毫秒）
* @param repeatCount 闪烁次数
* @param markerSymbolObject 脚本传入的标记符号对象
*/
function flashPoints(pointsString, delay, repeatCount, markerSymbolObject)
{
	getFlexApp('index').flashPoints(pointsString, delay, repeatCount, markerSymbolObject);
}

/**
* 闪烁线
* 
* @param polylineString 线字符串
* @param delay 闪烁间隔（毫秒）
* @param repeatCount 闪烁次数
* @param markerSymbolObject 脚本传入的线符号对象
*/
function flashPolyline(polylineString, delay, repeatCount, lineSymbolObject)
{
	getFlexApp('index').flashPolyline(polylineString, delay, repeatCount, lineSymbolObject);
}

/**
* 闪烁面
* 
* @param polylineString 面字符串
* @param delay 闪烁间隔（毫秒）
* @param repeatCount 闪烁次数
* @param markerSymbolObject 脚本传入的填充符号对象
*/
function flashPolygon(polygonString, delay, repeatCount, fillSymbolObject)
{
	getFlexApp('index').flashPolygon(polygonString, delay, repeatCount, fillSymbolObject);
}

/**
* 按时间动画线（线逐节点增长）
* 
* @param polylineString 线字符串
* @param lineSymbolObject 脚本传入的线符号对象
* @param duration 持续时间（毫秒）
*/
function animatePolylineInTime(polylineString, lineSymbolObject, duration)
{
	getFlexApp('index').animatePolylineInTime(polylineString, lineSymbolObject, duration);
}

/**
* 按速度动画线（线逐节点增长）
* 
* @param polylineString 线字符串
* @param lineSymbolObject 脚本传入的线符号对象
* @param speed 时速（每小时移动多少地图长度）
* @param ratio 真实动画比。实际1小时相当于多少毫秒动画时间
*/
function animatePolylineInSpeed(polylineString, lineSymbolObject, speed, ratio)
{
	getFlexApp('index').animatePolylineInSpeed(polylineString, lineSymbolObject, speed, ratio);
}

/**
* 设置点层渲染
* 
* @param layerId 点要素层id
* @param markerSymbolObject 脚本传入的标记符号对象
*/
function setPointLayerRenderer(layerId, markerSymbolObject)
{
	getFlexApp('index').setPointLayerRenderer(layerId, markerSymbolObject);
}

/**
* 设置点层图片渲染
* 
* @param layerId 线要素层id
* @param pictureMarkerSymbolObject 脚本传入的图片标记符号对象
*/
function setPointLayerPictureRenderer(layerId, pictureSymbolObject)
{
	getFlexApp('index').setPointLayerPictureRenderer(layerId, pictureSymbolObject);
}

/**
* 设置线层渲染
* 
* @param layerId 线要素层id
* @param lineSymbolObject 脚本传入的线符号对象
*/
function setLineLayerRenderer(layerId, lineSymbolObject)
{
	getFlexApp('index').setLineLayerRenderer(layerId, lineSymbolObject);
}

/**
* 设置面层渲染
* 
* @param layerId 面要素层id
* @param fillSymbolObject 脚本传入的填充符号对象
*/
function setPolygonLayerRenderer(layerId, fillSymbolObject)
{
	getFlexApp('index').setPolygonLayerRenderer(layerId, fillSymbolObject);
}

/**
* 添加点图形
* 
* @param pointsString 点字符串
* @param markerSymbolObject 脚本传入的标记符号对象
*/
function addPointGraphics(pointsString, markerSymbolObject)
{
	getFlexApp('index').addPointGraphics(pointsString, markerSymbolObject);
}

/**
* 添加点图片图形
* 
* @param pointsString 点字符串
* @param pictureSymbolObject 脚本传入的图片标记符号对象
*/
function addPictureGraphics(pointsString, pictureSymbolObject)
{
	getFlexApp('index').addPictureGraphics(pointsString, pictureSymbolObject)
}

/**
* 添加线图形
* 
* @param polylineString 线字符串
* @param lineSymbolObject 脚本传入的线符号对象
*/
function addPolylineGraphics(polylineString, lineSymbolObject)
{
	getFlexApp('index').addPolylineGraphics(polylineString, lineSymbolObject)
}

/**
* 添加面图形
* 
* @param polygonString 线字符串
* @param fillSymbolObject 脚本传入的线符号对象
*/
function addPolygonGraphics(polygonString, fillSymbolObject)
{
	getFlexApp('index').addPolygonGraphics(polygonString, fillSymbolObject)
}

/////////// 1.2 新增 ////////////////

/**
* 设置地图切片级别
* 
* @param level 目标级别
*/
function setLevel(level)
{
	getFlexApp('index').setLevel(level);
}       

/**
* 提升切片级别（放大）
*/
function levelUp()
{
	getFlexApp('index').levelUp();
} 

/**
* 降低切片级别（缩小）
*/
function levelDown()
{
	getFlexApp('index').levelDown();
} 

/**
* 地图中心放大
*/
function zoomIn()
{
	getFlexApp('index').zoomIn();
} 

/**
* 地图中心缩小
*/
function zoomOut()
{
	getFlexApp('index').zoomOut();
}

/**
* 按时间动画箭头线
* 
* @param polylineString 线字符串
* @param arrowLineSymbolObject 脚本传入的箭头线符号对象
* @param duration 持续时间（毫秒） 
* @param layerId 在指定图层上标记，默认为“HightlightLayer”
*/
function animateArrowLineInTime(polylineString, arrowLineSymbolObject, duration,layerId)
{
	getFlexApp('index').animateArrowLineInTime(polylineString, arrowLineSymbolObject,duration,layerId);
}

/**
* 按速度动画箭头线
* 
* @param polylineString 线字符串
* @param arrowLineSymbolObject 脚本传入的箭头线符号对象
* @param speed 时速（每小时移动多少地图长度）
* @param ratio 真实动画比。实际1小时相当于多少毫秒动画时间
*/
function animateArrowLineInSpeed(polylineString, arrowLineSymbolObject, speed, ratio)
{
	getFlexApp('index').animateArrowLineInSpeed(polylineString, arrowLineSymbolObject, speed, ratio);
}

/**
* 显示信息窗
* 
* @param x 显示位置的 x 坐标
* @param y 显示位置的 y 坐标
* @param title 信息窗的标题
* @param simpleHtml 信息窗的内容（仅支持简单 HTML，即文本、图片、链接等）
* @param width 信息窗的宽度，默认 300 像素
* @param height 信息窗的高度，默认 200 像素
*/
function showInfoWindow(x, y, title, simpleHtml, width, height)
{
	getFlexApp('index').showInfoWindow(x, y, title, simpleHtml, width, height)
}

/**
* 添加多边形及其信息窗
* 
* @param polygonString 面字符串
* @param fillSymbolObject 脚本传入的线符号对象
* @param mode 模式：click 单击打开模式，hover 悬停打开模式，默认为 click
* @param title 信息窗的标题
* @param simpleHtml 信息窗的内容（仅支持简单 HTML，即文本、图片、链接等）
* @param width 信息窗的宽度，默认 300 像素
* @param height 信息窗的高度，默认 200 像素
*/
function addPolygonGraphicInfoWindow(polygonString, fillSymbolObject, mode, title, simpleHtml, width, height)
{
	getFlexApp('index').addPolygonGraphicInfoWindow(polygonString, fillSymbolObject, mode, title, simpleHtml, width, height);
}

//// flex 事件处理函数（可修改函数体） /////
function onDrawEnd(polygonJSON)
{
	console.log(polygonJSON);
}


/////////// 1.3 新增 ////////////////

function zoomAt(level, x, y)
{
	getFlexApp('index').zoomAt(level, x, y);
//	getFlexApp('index').centerAt(x,y);
}

/**
 * 地图范围变化处理函数
 */
function onMapExtentChange()
{
	console.log("on map extent change");
}

function addPointInfoWindow(id,x, y, markerSymbolObject, mode, title, simpleHtml, width, height,xoff,yoff,layerId)
{

	if(arguments.length==12)
	{
		getFlexApp('index').addPointInfoWindow(id,x, y, markerSymbolObject, mode, title, simpleHtml, width, height,xoff,yoff,layerId);
	}
	else
	{
		getFlexApp('index').addPointInfoWindow(id,x, y, markerSymbolObject, mode, title, simpleHtml, width, height,xoff,yoff);	
	}
	
}

 /**
*调用弹出窗口
**/
function getDlg(url,tabid,title,w,h)
{
	top.getDlg(url,tabid,title,w,h);
}


/**************业务调用公共*******************/

//定义其它业务里回调函数
var callbackFunction=null;
var defaultJsCallFunctionString="defaultJsCallFunction";

function defaultJsCallFunction(obj)
{	
	if(callbackFunction!=null)
	{
		callbackFunction(obj);
		callbackFunction=null;
	}
	
}

/**
* 从地图获取坐标
* 
* @param callback js回调函数对象
*/
function getXY(callback)
{	
	try 
	{		
		if(callback==null) return ;
		
		var map=getFlexApp('index');
		callbackFunction=callback;					
		map.getXY(defaultJsCallFunctionString);			
	}
	catch(exception)
	{
		alert(exception);		
	}					
}

/**
* 编辑线
* @param grahpicID 图形唯一ID
* @param drawType 图形类型:freehandpolygon/freehandpolyline/polyline/polygon/extent/mappoint
*/
function drawGraphic(grahpicID,drawType,callback)
{
	
	try 
	{
		var map=getFlexApp('index');
		
		if(arguments.length==2)
		{												
			map.drawGraphic(grahpicID,drawType); 
		}
		if(arguments.length==3)
		{
			callbackFunction=callback;
			map.drawGraphic(grahpicID,drawType,defaultJsCallFunctionString); 
		}		
	}
	catch(exception)
	{
		alert(exception);					
	}
}

/**
 *编辑图形 
 * @param grahpicID 图形ID
 * @param geoJson Polyline或Polygon Json对象
 * 
 */
function editGraphic(grahpicID,geoJson)
{
	var geoJsonString=JSON.stringify(geoJson);            	
	geoJson=eval("("+geoJsonString+")");	
	try 
	{
		var map=getFlexApp('index');										
		map.editPolyline(grahpicID,geoJson);		
	}
	catch(exception)
	{
		alert(exception);					
	}
}

/**
* 编辑线
* @param grahpicID 图形ID
* @param polylineJson 线串坐标对，如:{"paths":[[[438489.08291525743,2557275.576483189],[485637.83291525743,2582993.076483189],[508974.08291525743,2568229.326483189],[517546.58291525743,2556799.326483189]]],"spatialReference":{"wkid":2383}};
*/
function editPolyline(grahpicID,polylineJson)
{
	var polylineString=JSON.stringify(polylineJson);            	
	polylineJson=eval("("+polylineString+")");	
	try 
	{
		var map=getFlexApp('index');										
		map.editPolyline(grahpicID,polylineJson);		
	}
	catch(exception)
	{
		alert(exception);					
	}
}


/**
*  编辑面
* @param grahpicID 图形ID
* @param polygonJson 线串坐标对，如:{"rings":[[[468738.2648499999,2578778.4647500003],[514934.5148499999,2597828.4647500003],[529698.2648499999,2566395.9647500003],[510648.2648499999,2548298.4647500003],[468738.2648499999,2578778.4647500003]]],"spatialReference":{"wkid":2383}};
*/
function editPolygon(grahpicID,polygonJson)
{
	var polygonString=JSON.stringify(polygonJson);            	
	polygonJson=eval("("+polygonString+")");
	
	try 
	{
		var map=getFlexApp('index');										
		map.editPolygon(grahpicID,polygonJson); 	
	}
	catch(exception)
	{
		alert(exception);
	}
}

 /**
*  编辑面
* @param grahpicID 图形ID;
* @param callback js回调函数对象
*/
function getEidtGraphic(grahpicID,callback)
{				
	try 
	{
		if(callback==null) return;
		
		var map=getFlexApp('index');
		callbackFunction=callback;											
		map.getEidtGraphic(grahpicID,defaultJsCallFunctionString);										 	
			
	}
	catch(exception)
	{
		alert(exception);	
	}          
}            

 /**
* 
* @param grahpicID 图形ID
* @param drawType 类型Point/Polyline/Polygon/Multipoint/Envelope
* @param geoJson ArcGIS Json Geometry Objects 
* @return 
* 
*/
function drawGraphicByErisGeoJson(grahpicID,drawType,geoJson)
{
	var geoString=JSON.stringify(geoJson);            	
	geoJson=eval("("+geoString+")");
	var map=getFlexApp('index');
	map.drawGraphicByErisGeoJson(grahpicID,drawType,geoJson);			
}

/**
*启动GeometryNetworkAnalysis（目前供停气分析使用） 
* @param x 类型：Number
* @param y ,类型：Number
* @param tolerance 类型：Number 容差,可为空
* @param elementType 类型：String 容差,可为空 值为junction/edge/both
* @param callback 回调JS函数,可为空
* 
*/
function startGeoNetworkAnalysis(x,y,tolerance,elementType,callback)
{
	var map=getFlexApp('index');
	
	
	if(arguments.length==2)
	{
		map.startGeoNetworkAnalysis(x,y);
	}
	else if(arguments.length==3)
	{
		map.startGeoNetworkAnalysis(x,y,tolerance,elementType);
	}
	else if(arguments.length==4)
	{
		map.startGeoNetworkAnalysis(x,y,tolerance,elementType);
	}	
	else if(arguments.length==5)
	{
		if(callback!=null)
		{
			callbackFunction=callback;
			map.startGeoNetworkAnalysis(x,y,tolerance,elementType,defaultJsCallFunctionString);
		}
		else
		{
			map.startGeoNetworkAnalysis(x,y,tolerance,elementType);
		}
	}
}

/**
*从地图取点启动GeoNetwork 
* @param callback 回调JS函数,可为空
* 
*/
function startGeoNetworkAnalysisWithMap(callback)
{
	var map=getFlexApp('index');
	if(arguments.length==0)
	{
		map.startGeoNetworkAnalysisWithMap();
	}
	else if(arguments.length==1)
	{
		if(callback!=null)
		{
			callbackFunction=callback;
			map.startGeoNetworkAnalysisWithMap(defaultJsCallFunctionString);
		}
		else
		{
			map.startGeoNetworkAnalysisWithMap();
		}		
	}
}


/******************以上为2012.3.9 22：15更新********/

/**
 *绘制图形统一接口 
 * @param id	图形Id
 * @param geometryObject 图形几何Json对象,格式参考Arcgis server Rest API之GeometryObject
 * @param tipMode	tip显示模式，可为none\open\hover\click,默认为none
 * @param attribute 属性Json对象,默认为空
 * @param symbolObject	图形样式Json对象,默认为空,格式参考Arcgis server Rest API之Symbol Objects
 * @param tipClass	tip类型,可为空,默认为"SimpleHtml"
 * @param tipWidth	tip框宽度,默认为200，可为空
 * @param tipHeight	tip框高度,默认为200，可为空		 
 * @param tipUrl	当tipClass为IFrame时，IFrame地址,可为空
 * @param autoZoom 是否自动缩放,可为空，默认值为true
 * @param layerId 在指定层上添加标记
 * 
 */
function addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass,tipWidth,tipHeight,tipUrl,autoZoom,layerId)
{
	var map=getFlexApp('index');

	if(arguments.length==2)
	{
		map.addGraphic(id,geometryObject);
	}
	else if(arguments.length==3)
	{
		map.addGraphic(id,geometryObject,tipMode);
	}
	else if(arguments.length==4)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute);
	}
	else if(arguments.length==5)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject);
	}
	else if(arguments.length==6)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass);
	}
	else if(arguments.length==7)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass,tipWidth);
	}
	else if(arguments.length==8)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass,tipWidth,tipHeight);
	}
	else if(arguments.length==9)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass,tipWidth,tipHeight,tipUrl);
	}
	else if(arguments.length==10)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass,tipWidth,tipHeight,tipUrl,autoZoom);
	}
	else if(arguments.length==11)
	{
		map.addGraphic(id,geometryObject,tipMode,attribute,symbolObject,tipClass,tipWidth,tipHeight,tipUrl,autoZoom,layerId);
	}
}

/**
 *范围缩放 
 * @param xmin
 * @param ymin
 * @param xmax
 * @param ymax
 * 
 */
function zoomExtent(xmin,ymin,xmax,ymax)
{
	var map=getFlexApp('index');
	map.zoomExtent(xmin,ymin,xmax,ymax);
}

/**
 * 根据几何图形数组缩放地图
 * @param geometryJsons	Json几何图形数组
 * 
 */
function zoomGeometrys(geometryJsons)
{
	var map=getFlexApp('index');
	map.zoomGeometrys(geometryJsons);
}

/**
 *画圆 
 * @param center 中心点GeoJson
 * @param radius	半径,为m
 * @param callback	画圆后回调函数，返回PolygonJson,可为空
 * @param centerMarkerSymbol 圆点标记SymbolJson，可为空
 * 
 */
function addCircle(center,radius,callback,centerMarkerSymbol)
{
	var map=getFlexApp('index');

	if(arguments.length==2)
	{
		map.addCircle(center,radius);
	}
	else if(arguments.length==3)
	{
		if(callback!=null&&callback!="")
		{
			callbackFunction=callback;
			map.addCircle(center,radius,defaultJsCallFunctionString);
		}
		else
		{
			map.addCircle(center,radius);
		}
	}
	else if(arguments.length==4)
	{
		if(callback!=null&&callback!="")
		{
			callbackFunction=callback;
			map.addCircle(center,radius,defaultJsCallFunctionString,centerMarkerSymbol);
		}
		else
		{
			map.addCircle(center,radius,"",centerMarkerSymbol);
		}	
	}
}

/****************地图缩放事件函数变量声明*********************/

var zoomEventCallFunction;
var zoomEventBriage="zoomEventBriageCallback";

/**
 *添加地图缩放事件监听 
 * @param callback JS回调函数
 * 
 */
function addZoomEventListener(callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		zoomEventCallFunction=callback;
		map.addZoomEventListener(zoomEventBriage);
	}
}

/**
 *移除地图缩放事件监听 
 * 
 */
function removeZoomEventListener()
{
	var map=getFlexApp('index');
	map.removeZoomEventListener();
}

function zoomEventBriageCallback(obj)
{
	if(zoomEventCallFunction!=null)
	{
		zoomEventCallFunction(obj);
	}
	else
	{
		removeZoomEventListener();
	}
}

/**
 *专题绘图 
 * @param ids 图形Id数组 （长度必须与geometryObjects数组长度一致）
 * @param geometryObjects 图形几何Json数组（长度必须与ids数组长度一致）
 * @param tipModes	tip显示模式数组（可为空，长度可与ids数组长度一致，不一致时，其它值与第一个值一致）[单个值可为none\open\hover\click,默认为none]
 * @param attributes 图形属性数组(可为空,长度可与ids数组长度一致，不一致时，其它值与第一个值一致)
 * @param symbolObjects 标记对象数组（可为空,长度可与ids数组长度一致，不一致时，其它值与第一个值一致）
 * @param tipClasses tip类型（可为空,长度可与ids数组长度一致，不一致时，其它值与第一个值一致）[值可为IFrame|none]
 * @param tipWidths tip的宽度（可为空,长度可与ids数组长度一致，不一致时，其它值与第一个值一致）
 * @param tipHeights	tip的高度（可为空,长度可与ids数组长度一致，不一致时，其它值与第一个值一致）
 * @param tipUrls	tipUrl（可为空,长度可与ids数组长度一致，不一致时，其它值与第一个值一致）,当tipclass为IFrame时，该值不能为空
 * @param layerId 在指定层上添加标记
 * 
 */
function addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects,tipClasses,tipWidths,tipHeights,tipUrls,layerId)
{
	var map=getFlexApp('index');

	if(arguments.length==2)
	{
		map.addGraphics(ids,geometryObjects);
	}
	else if(arguments.length==3)
	{
		map.addGraphics(ids,geometryObjects,tipModes);
	}
	else if(arguments.length==4)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes);
	}
	else if(arguments.length==5)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects);
	}
	else if(arguments.length==6)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects,tipClasses);
	}
	else if(arguments.length==7)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects,tipClasses,tipWidths);
	}
	else if(arguments.length==8)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects,tipClasses,tipWidths,tipHeights);
	}
	else if(arguments.length==9)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects,tipClasses,tipWidths,tipHeights,tipUrls);
	}
	else if(arguments.length==10)
	{
		map.addGraphics(ids,geometryObjects,tipModes,attributes,symbolObjects,tipClasses,tipWidths,tipHeights,tipUrls,layerId);
	}
	
}

/**
 *获得当前地图级数 
 * @param callbackFunction
 * 
 */
function getMapLevel(callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		callbackFunction=callback;					
		map.getMapLevel(defaultJsCallFunctionString);	
	}
}

/*
 * 
 * @param {Object} obj
 */
function geoAreaQueryFlex(obj)
{
	top.geoAreaQuery(obj);
}

function defautJSCallback(obj)
{
	alert(decodeURI(obj));
}

/*
 * 供地图获得当前登录用户
 * @return {TypeName} 
 */
function getUser()
{
	//return "admin";
	return top.userId;
}

/*
 * 供地图获得当前用户的权限图层(地图初始化时使用)
 * @return {String} 
 */
function getVerifiedLayer()
{
	//return "layerSetBasemaps,layerDlg,layerDom1,layerDom2";
	return top.verifiedLayer;
}

/*
 * 设置用户权限图层
 * @param {String} layIds
 */
function setVerifiedLayer(layIds)
{
	var map=getFlexApp('index');
	map.setVerifiedLayer(layIds);
}

/*
 * 获得当前语言
 * @return {String} 
 */
function getLanguage()
{
	return top.language=="undefined"?"":top.language;
}


/**
 * 删除图形 
 * 
 * @param ids 图形Id集合字符串，以逗号隔开;或用*号表示删除指定图层上的全部标记
 * @param layerId 标记图层ID，默认为“HightlightLayer”
 * 
 */		
function removeGraphics(ids,layerId)
{
	var map=getFlexApp('index');

	if(arguments.length==1)
	{
		map.removeGraphics(ids);
	}
	else if(arguments.length==2)
	{
		map.removeGraphics(ids,layerId);
	}
}

/**
 *获得中心点坐标 
 * @param strGeo 几何对象JSON字符串
 * @return MapPoint JSONString
 * 
 */
function getCenterLocation(strGeo)
{
	var map=getFlexApp('index');

	if(arguments.length==1)
	{
		return map.getCenterLocation(strGeo);
	}	
}

/**
 *闪烁标记，闪烁后支持鼠标交互行为
 *  
 * @param id 图形Id
 * @param geometryObject 图形几何Json对象,格式参考Arcgis server Rest API之GeometryObject
 * @param symbolObject 图形样式Json对象,默认为空,格式参考Arcgis server Rest API之Symbol Objects
 * @param delay 闪烁间隔（毫秒）
 * @param repeatCount 闪烁次数 
 * @param tipMode tip显示模式，可为none\open\hover\click,默认为none
 * @param attribute 属性Json对象,默认为空		
 * @param tipClass tip类型,可为空 [值可为IFrame|None,默认为None]
 * @param tipWidth tip框宽度,默认为200，可为空
 * @param tipHeight tip框高度,默认为200，可为空		
 * @param tipUrl 当tipClass为IFrame时，IFrame地址,可为空
 * @param autoZoom 是否自动缩放
 * 
 */
function flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute,tipClass,tipWidth,tipHeight,tipUrl,autoZoom)
{
	var map=getFlexApp('index');

	if(arguments.length==2)
	{
		map.flashGraphic(id,geometryObject);
	}
	else if(arguments.length==3)
	{
		map.flashGraphic(id,geometryObject,symbolObject);
	}
	else if(arguments.length==4)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay);
	}
	else if(arguments.length==5)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount);
	}
	else if(arguments.length==6)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode);
	}
	else if(arguments.length==7)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute);
	}
	else if(arguments.length==8)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute,tipClass);
	}
	else if(arguments.length==9)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute,tipClass,tipWidth);
	}
	else if(arguments.length==10)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute,tipClass,tipWidth,tipHeight);
	}
	else if(arguments.length==11)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute,tipClass,tipWidth,tipHeight,tipUrl);
	}
	else if(arguments.length==12)
	{
		map.flashGraphic(id,geometryObject,symbolObject,delay, repeatCount,tipMode,attribute,tipClass,tipWidth,tipHeight,tipUrl,autoZoom);
	}
}

/**
 *获取图形几何坐标 
 * @param id 图形唯一id
 * @param callbackFunction 回调js函数
 * 
 */
function getGraphic(id,callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		callbackFunction=callback;					
		map.getGraphic(id,defaultJsCallFunctionString);	
	}
}

/**
 *绘制路由 
 * @param grahpicID 路由图形id
 * @param callbackFunction 绘制完后回调函数，返回RouteObject
 * 
 */
function drawRoute(grahpicID,callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		callbackFunction=callback;					
		map.drawRoute(grahpicID,defaultJsCallFunctionString);	
	}
}

/**
 * 编辑路由
 * @param grahpicID 路由图形id
 * @param routeObject 路由Json对象,格式参考对象Json说明之RouteObject
 * @param callbackFunction 编辑完后回调函数,返回RouteObject
 * 
 */
function editRoute(grahpicID,routeObject,callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		callbackFunction=callback;					
		map.editRoute(grahpicID,routeObject,defaultJsCallFunctionString);	
	}
	else
	{
		map.editRoute(grahpicID,routeObject);
	}
}


/**
 * 获取路由坐标
 * @param grahpicID 路由图形id
 * @param callbackFunction 编辑完后回调函数 返回RouteObject
 * 
 */
function getRoute(grahpicID,callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		callbackFunction=callback;					
		map.getRoute(grahpicID,defaultJsCallFunctionString);	
	}
}

/**
 * 定位路由
 * @param grahpicID 路由图形id
 * @param routeObject 路由Json对象,格式参考对象Json说明之RouteObject
 * @param callbackFunction 编辑完后回调函数,返回空值
 * 
 */
function locateRoute(grahpicID,routeObject,callback)
{
	var map=getFlexApp('index');
	if(callback!=null)
	{
		callbackFunction=callback;					
		map.locateRoute(grahpicID,routeObject,defaultJsCallFunctionString);	
	}
	else
	{
		map.locateRoute(grahpicID,routeObject);
	}
}